/*
 *
 *    Copyright (c) 2022 Project CHIP Authors
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */

// THIS FILE IS GENERATED BY ZAP
// This file is generated from clusters-Commands.h.zapt

#pragma once

#include <app/data-model/DecodableList.h>
#include <app/data-model/Encode.h>
#include <app/data-model/List.h>
#include <app/data-model/NullObject.h>
#include <app/data-model/Nullable.h>
#include <lib/core/DataModelTypes.h>
#include <lib/core/Optional.h>
#include <lib/core/TLV.h>
#include <lib/support/BitMask.h>

#include <clusters/shared/Enums.h>
#include <clusters/shared/Structs.h>

#include <clusters/Thermostat/ClusterId.h>
#include <clusters/Thermostat/CommandIds.h>
#include <clusters/Thermostat/Enums.h>
#include <clusters/Thermostat/Structs.h>

#include <cstdint>

namespace chip
{
namespace app
{
	namespace Clusters
	{
		namespace Thermostat
		{
			namespace Commands
			{
				// Forward-declarations so we can reference these later.

				namespace SetpointRaiseLower
				{
					struct Type;
					struct DecodableType;
				} // namespace SetpointRaiseLower

				namespace GetWeeklyScheduleResponse
				{
					struct Type;
					struct DecodableType;
				} // namespace GetWeeklyScheduleResponse

				namespace SetWeeklySchedule
				{
					struct Type;
					struct DecodableType;
				} // namespace SetWeeklySchedule

				namespace GetWeeklySchedule
				{
					struct Type;
					struct DecodableType;
				} // namespace GetWeeklySchedule

				namespace AddThermostatSuggestionResponse
				{
					struct Type;
					struct DecodableType;
				} // namespace AddThermostatSuggestionResponse

				namespace ClearWeeklySchedule
				{
					struct Type;
					struct DecodableType;
				} // namespace ClearWeeklySchedule

				namespace SetActiveScheduleRequest
				{
					struct Type;
					struct DecodableType;
				} // namespace SetActiveScheduleRequest

				namespace SetActivePresetRequest
				{
					struct Type;
					struct DecodableType;
				} // namespace SetActivePresetRequest

				namespace AddThermostatSuggestion
				{
					struct Type;
					struct DecodableType;
				} // namespace AddThermostatSuggestion

				namespace RemoveThermostatSuggestion
				{
					struct Type;
					struct DecodableType;
				} // namespace RemoveThermostatSuggestion

				namespace AtomicResponse
				{
					struct Type;
					struct DecodableType;
				} // namespace AtomicResponse

				namespace AtomicRequest
				{
					struct Type;
					struct DecodableType;
				} // namespace AtomicRequest

			} // namespace Commands

			namespace Commands
			{
				namespace SetpointRaiseLower
				{
					enum class Fields : uint8_t {
						kMode = 0,
						kAmount = 1,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::SetpointRaiseLower::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::Thermostat::Id;
						}

						SetpointRaiseLowerModeEnum mode =
							static_cast<SetpointRaiseLowerModeEnum>(0);
						int8_t amount = static_cast<int8_t>(0);

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::SetpointRaiseLower::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::Thermostat::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						SetpointRaiseLowerModeEnum mode =
							static_cast<SetpointRaiseLowerModeEnum>(0);
						int8_t amount = static_cast<int8_t>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace SetpointRaiseLower
				namespace GetWeeklyScheduleResponse
				{
					enum class Fields : uint8_t {
						kNumberOfTransitionsForSequence = 0,
						kDayOfWeekForSequence = 1,
						kModeForSequence = 2,
						kTransitions = 3,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::GetWeeklyScheduleResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::Thermostat::Id;
						}

						uint8_t numberOfTransitionsForSequence = static_cast<uint8_t>(0);
						chip::BitMask<ScheduleDayOfWeekBitmap> dayOfWeekForSequence =
							static_cast<chip::BitMask<ScheduleDayOfWeekBitmap>>(0);
						chip::BitMask<ScheduleModeBitmap> modeForSequence =
							static_cast<chip::BitMask<ScheduleModeBitmap>>(0);
						DataModel::List<const Structs::WeeklyScheduleTransitionStruct::Type>
							transitions;

						CHIP_ERROR Encode(DataModel::FabricAwareTLVWriter &aWriter,
								  TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::GetWeeklyScheduleResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::Thermostat::Id;
						}

						uint8_t numberOfTransitionsForSequence = static_cast<uint8_t>(0);
						chip::BitMask<ScheduleDayOfWeekBitmap> dayOfWeekForSequence =
							static_cast<chip::BitMask<ScheduleDayOfWeekBitmap>>(0);
						chip::BitMask<ScheduleModeBitmap> modeForSequence =
							static_cast<chip::BitMask<ScheduleModeBitmap>>(0);
						DataModel::DecodableList<
							Structs::WeeklyScheduleTransitionStruct::DecodableType>
							transitions;

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace GetWeeklyScheduleResponse
				namespace SetWeeklySchedule
				{
					enum class Fields : uint8_t {
						kNumberOfTransitionsForSequence = 0,
						kDayOfWeekForSequence = 1,
						kModeForSequence = 2,
						kTransitions = 3,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::SetWeeklySchedule::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::Thermostat::Id;
						}

						uint8_t numberOfTransitionsForSequence = static_cast<uint8_t>(0);
						chip::BitMask<ScheduleDayOfWeekBitmap> dayOfWeekForSequence =
							static_cast<chip::BitMask<ScheduleDayOfWeekBitmap>>(0);
						chip::BitMask<ScheduleModeBitmap> modeForSequence =
							static_cast<chip::BitMask<ScheduleModeBitmap>>(0);
						DataModel::List<const Structs::WeeklyScheduleTransitionStruct::Type>
							transitions;

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::SetWeeklySchedule::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::Thermostat::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						uint8_t numberOfTransitionsForSequence = static_cast<uint8_t>(0);
						chip::BitMask<ScheduleDayOfWeekBitmap> dayOfWeekForSequence =
							static_cast<chip::BitMask<ScheduleDayOfWeekBitmap>>(0);
						chip::BitMask<ScheduleModeBitmap> modeForSequence =
							static_cast<chip::BitMask<ScheduleModeBitmap>>(0);
						DataModel::DecodableList<
							Structs::WeeklyScheduleTransitionStruct::DecodableType>
							transitions;

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace SetWeeklySchedule
				namespace GetWeeklySchedule
				{
					enum class Fields : uint8_t {
						kDaysToReturn = 0,
						kModeToReturn = 1,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::GetWeeklySchedule::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::Thermostat::Id;
						}

						chip::BitMask<ScheduleDayOfWeekBitmap> daysToReturn =
							static_cast<chip::BitMask<ScheduleDayOfWeekBitmap>>(0);
						chip::BitMask<ScheduleModeBitmap> modeToReturn =
							static_cast<chip::BitMask<ScheduleModeBitmap>>(0);

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = Clusters::Thermostat::Commands::
							GetWeeklyScheduleResponse::DecodableType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::GetWeeklySchedule::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::Thermostat::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						chip::BitMask<ScheduleDayOfWeekBitmap> daysToReturn =
							static_cast<chip::BitMask<ScheduleDayOfWeekBitmap>>(0);
						chip::BitMask<ScheduleModeBitmap> modeToReturn =
							static_cast<chip::BitMask<ScheduleModeBitmap>>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace GetWeeklySchedule
				namespace AddThermostatSuggestionResponse
				{
					enum class Fields : uint8_t {
						kUniqueID = 0,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::AddThermostatSuggestionResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::Thermostat::Id;
						}

						uint8_t uniqueID = static_cast<uint8_t>(0);

						CHIP_ERROR Encode(DataModel::FabricAwareTLVWriter &aWriter,
								  TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::AddThermostatSuggestionResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::Thermostat::Id;
						}

						uint8_t uniqueID = static_cast<uint8_t>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace AddThermostatSuggestionResponse
				namespace ClearWeeklySchedule
				{
					enum class Fields : uint8_t {};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::ClearWeeklySchedule::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::Thermostat::Id;
						}

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::ClearWeeklySchedule::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::Thermostat::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace ClearWeeklySchedule
				namespace SetActiveScheduleRequest
				{
					enum class Fields : uint8_t {
						kScheduleHandle = 0,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::SetActiveScheduleRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::Thermostat::Id;
						}

						chip::ByteSpan scheduleHandle;

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::SetActiveScheduleRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::Thermostat::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						chip::ByteSpan scheduleHandle;

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace SetActiveScheduleRequest
				namespace SetActivePresetRequest
				{
					enum class Fields : uint8_t {
						kPresetHandle = 0,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::SetActivePresetRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::Thermostat::Id;
						}

						DataModel::Nullable<chip::ByteSpan> presetHandle;

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::SetActivePresetRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::Thermostat::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						DataModel::Nullable<chip::ByteSpan> presetHandle;

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace SetActivePresetRequest
				namespace AddThermostatSuggestion
				{
					enum class Fields : uint8_t {
						kPresetHandle = 0,
						kEffectiveTime = 1,
						kExpirationInMinutes = 2,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::AddThermostatSuggestion::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::Thermostat::Id;
						}

						chip::ByteSpan presetHandle;
						DataModel::Nullable<uint32_t> effectiveTime;
						uint16_t expirationInMinutes = static_cast<uint16_t>(0);

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = Clusters::Thermostat::Commands::
							AddThermostatSuggestionResponse::DecodableType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::AddThermostatSuggestion::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::Thermostat::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						chip::ByteSpan presetHandle;
						DataModel::Nullable<uint32_t> effectiveTime;
						uint16_t expirationInMinutes = static_cast<uint16_t>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace AddThermostatSuggestion
				namespace RemoveThermostatSuggestion
				{
					enum class Fields : uint8_t {
						kUniqueID = 0,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::RemoveThermostatSuggestion::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::Thermostat::Id;
						}

						uint8_t uniqueID = static_cast<uint8_t>(0);

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::RemoveThermostatSuggestion::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::Thermostat::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						uint8_t uniqueID = static_cast<uint8_t>(0);

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace RemoveThermostatSuggestion
				namespace AtomicResponse
				{
					enum class Fields : uint8_t {
						kStatusCode = 0,
						kAttributeStatus = 1,
						kTimeout = 2,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::AtomicResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::Thermostat::Id;
						}

						uint8_t statusCode = static_cast<uint8_t>(0);
						DataModel::List<const Globals::Structs::AtomicAttributeStatusStruct::Type>
							attributeStatus;
						Optional<uint16_t> timeout;

						CHIP_ERROR Encode(DataModel::FabricAwareTLVWriter &aWriter,
								  TLV::Tag aTag) const;

						using ResponseType = DataModel::NullObjectType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::AtomicResponse::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::Thermostat::Id;
						}

						uint8_t statusCode = static_cast<uint8_t>(0);
						DataModel::DecodableList<
							Globals::Structs::AtomicAttributeStatusStruct::DecodableType>
							attributeStatus;
						Optional<uint16_t> timeout;

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace AtomicResponse
				namespace AtomicRequest
				{
					enum class Fields : uint8_t {
						kRequestType = 0,
						kAttributeRequests = 1,
						kTimeout = 2,
					};

					struct Type {
					public:
						// Use GetCommandId instead of commandId directly to avoid naming
						// conflict with CommandIdentification in ExecutionOfACommand
						static constexpr CommandId GetCommandId()
						{
							return Commands::AtomicRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::Thermostat::Id;
						}

						Globals::AtomicRequestTypeEnum requestType =
							static_cast<Globals::AtomicRequestTypeEnum>(0);
						DataModel::List<const chip::AttributeId> attributeRequests;
						Optional<uint16_t> timeout;

						CHIP_ERROR Encode(TLV::TLVWriter &aWriter, TLV::Tag aTag) const;

						using ResponseType =
							Clusters::Thermostat::Commands::AtomicResponse::DecodableType;

						static constexpr bool MustUseTimedInvoke() { return false; }
					};

					struct DecodableType {
					public:
						static constexpr CommandId GetCommandId()
						{
							return Commands::AtomicRequest::Id;
						}
						static constexpr ClusterId GetClusterId()
						{
							return Clusters::Thermostat::Id;
						}
						static constexpr bool kIsFabricScoped = false;

						Globals::AtomicRequestTypeEnum requestType =
							static_cast<Globals::AtomicRequestTypeEnum>(0);
						DataModel::DecodableList<chip::AttributeId> attributeRequests;
						Optional<uint16_t> timeout;

						CHIP_ERROR Decode(TLV::TLVReader &reader);
					};
				}; // namespace AtomicRequest
			} // namespace Commands
		} // namespace Thermostat
	} // namespace Clusters
} // namespace app
} // namespace chip
